import Request from './request'
import {
    baseApiUri,
    testApiUri,
} from './baseConfig'

// 判断是否是json
function isJson(str) {
    if (typeof str !== 'string') {
        return false;
    }
    try {
        let obj = JSON.parse(str);
        return !!obj && typeof obj === 'object';
    } catch (e) {
        return false;
    }
}

// 请求之前的参数
let requestData = null;


// 测试
const test = new Request()

test.setConfig((config) => {
    /* 设置全局配置 */
    config.baseUrl = testApiUri
    config.header = {
        ...config.header,
    }
    return config
})

test.interceptor.request((config, cancel) => {
    /* 请求之前拦截器 */
    config.header = {
        ...config.header,
    }
    /*
    if (!token) { // 如果token不存在，调用cancel 会取消本次请求，但是该函数的catch() 仍会执行
      cancel('token 不存在') // 接收一个参数，会传给catch((err) => {}) err.errMsg === 'token 不存在'
    }
    */
    requestData = config.data;

    if (requestData && requestData.showLoading) {
        uni.showLoading({
            title: '加载中',
            mask: true
        });
    }
    return config
})

/**
 * 自定义验证器，如果返回true 则进入响应拦截器的响应成功函数(resolve)，否则进入响应拦截器的响应错误函数(reject)
 * @param { Number } statusCode - 请求响应体statusCode（只读）
 * @return { Boolean } 如果为true,则 resolve, 否则 reject
 */
test.validateStatus = (statusCode) => {
    return statusCode === 200
}

test.interceptor.response((response) => {
    /* 请求之后拦截器 */
    if (isJson(response.data)) {
        response.data = JSON.parse(response.data);
    }
    if (requestData.data.hideLoading) {
        uni.hideLoading()
    }
    if (response.data.resultCode != 1) { // 服务端返回的状态码不等于1，则reject()
        return Promise.reject(response.data)
    }
    return response.data
}, (error) => { // 请求错误做点什么
    if (isJson(error.data)) {
        error.data = JSON.parse(error.data);
    }
    if (requestData.data.hideLoading) {
        uni.hideLoading()
    }
    return error.data
})

/**
 * 正式
 */
const http = new Request()

http.setConfig((config) => {
    /* 设置全局配置 */
    config.baseUrl = baseApiUri /* 根域名不同 */
    config.header = {
        ...config.header,
    }
    return config
})

/**
 * 自定义验证器，如果返回true 则进入响应拦截器的响应成功函数(resolve)，否则进入响应拦截器的响应错误函数(reject)
 * @param { Number } statusCode - 请求响应体statusCode（只读）
 * @return { Boolean } 如果为true,则 resolve, 否则 reject
 */

http.interceptor.request((config, cancel) => {
    // console.log('config', config);
    /* 请求之前拦截器 */
    config.header = {
        ...config.header,
    }
    /*
    if (!token) { // 如果token不存在，调用cancel 会取消本次请求，但是该函数的catch() 仍会执行
      cancel('token 不存在') // 接收一个参数，会传给catch((err) => {}) err.errMsg === 'token 不存在'
    }
    */
    requestData = config.data;

    if (requestData && requestData.showLoading) {
        uni.showLoading({
            title: '加载中',
            mask: true
        });
    }
    // console.log('requestData', requestData);
    return config
})

http.validateStatus = (statusCode) => {
    return statusCode === 200
}


/* 请求之后拦截器 */
http.interceptor.response((response) => {
    // console.log('response', response);
    if (isJson(response.data)) {
        response.data = JSON.parse(response.data);
    }

    if (requestData.data.hideLoading) {
        uni.hideLoading()
    }
    if (response.data.resultCode != 1) { // 服务端返回的状态码不等于1，则reject()
        return Promise.reject(response.data)
    }
    return response.data
}, (error) => { // 请求错误做点什么
    if (isJson(error.data)) {
        error.data = JSON.parse(error.data);
    }
    if (requestData.data.hideLoading) {
        uni.hideLoading()
    }
    return error.data
})

/**
 * 文件服务器上传
 */
const httpFile = new Request()

httpFile.setConfig((config) => {
    /* 设置全局配置 */
    config.baseUrl = baseApiUri /* 根域名不同 */
    config.header = {
        ...config.header,
    }
    return config
})

/**
 * 自定义验证器，如果返回true 则进入响应拦截器的响应成功函数(resolve)，否则进入响应拦截器的响应错误函数(reject)
 * @param { Number } statusCode - 请求响应体statusCode（只读）
 * @return { Boolean } 如果为true,则 resolve, 否则 reject
 */
httpFile.validateStatus = (statusCode) => {
    return statusCode === 200
}

httpFile.interceptor.request((config, cancel) => {
    // console.log('config', config);
    /* 请求之前拦截器 */
    config.header = {
        ...config.header,
    }
    /*
    if (!token) { // 如果token不存在，调用cancel 会取消本次请求，但是该函数的catch() 仍会执行
      cancel('token 不存在') // 接收一个参数，会传给catch((err) => {}) err.errMsg === 'token 不存在'
    }
    */
    // requestData = config.data;
    // if (requestData && requestData.showLoading ||
    //     (config.formData && config.formData.showLoading)) {
    //     uni.showLoading({
    //         title: '上传中',
    //         mask: true
    //     });
    // }
    return config
})

/* 请求之后拦截器 */
httpFile.interceptor.response((response) => {
    if (isJson(response.data)) {
        response.data = JSON.parse(response.data);
    }

    // if (requestData.hideLoading) {
    //     uni.hideLoading()
    // }
    if (response.data.resultCode != 1) { // 文件服务器返回的状态码不等于0，则reject()
        return Promise.reject(response.data)
    }
    return response.data
}, (error) => { // 请求错误做点什么
    if (isJson(error.data)) {
        error.data = JSON.parse(error.data);
    }
    // if (requestData.hideLoading) {
    //     uni.hideLoading()
    // }
    return error.data
})

export {
    http,
    httpFile,
    test
}